import singleton from "@/utils/libs/singleton";
import serial from "./serial";
import {
	runderStore
} from "@/store";

class RunStep {
	#serial;
	#i = 0; // 当前步骤索引
	totalSetp = 0; //总步骤数
	currentStep = 0; // 当前步骤索引
	// 配置参数（可根据实际需求调整）
	dryPressureThreshold = 0; // 干燥压力阈值
	leakThreshold = 0; // 泄漏率阈值
	plasmaMaxRetry = 3; // 等离子最大重试次数
	plasmaRetryCount = 0; // 等离子当前重试次数


	menu = ["预真空", "注液", "扩散", "等离子", "新风"];
	store; //pina

	// 集中管理所有步骤配置
	steps = [
		//第一步
		[{
				canId: 1010,
				delay: 12000, // 12秒
				msg: "真空期内胆降压",
				desc: "用时120S 未到干燥压力值报警，4秒内检测一次",
				ttl: 12,
				errorCheck: (data) => this.checkPressure(data, 'dry')
			},
			{
				canId: 1020,
				delay: 4000, // 4秒
				msg: "测漏检测",
				desc: "用时40S 升压速率>腔体升压速率,报警E3",
				ttl: 4,
				errorCheck: (data) => this.checkLeakRate(data)
			},
			{
				canId: 1030,
				delay: 3000, // 3秒
				msg: "常压真空预热",
				desc: "立即执行未有其他要求",
				ttl: 3,
				errorCheck: () => null // 无特殊校验
			},
			{
				canId: 1040,
				delay: 12000, // 12秒
				msg: "内胆降压和蒸发器降压",
				desc: "用时120S 灭菌舱的压力应低于“真空期内胆降压值 报警E1",
				ttl: 12,
				errorCheck: (data) => this.checkPressure(data, 'vacuum')
			},
			{
				canId: 1050,
				delay: 9000, // 9秒
				msg: "灭菌舱的压力值",
				desc: "灭菌舱的泄漏值应小于“真空期内胆泄漏率设置 报警E3",
				ttl: 9,
				errorCheck: (data) => this.checkLeakRate(data)
			},
			{
				canId: 1060,
				delay: 3000, // 3秒
				msg: "抽真空",
				desc: "等离子开启前将内胆压力抽到180Pa",
				ttl: 3,
				errorCheck: (data) => this.checkPlasmaPressure(data)
			},
			{
				canId: 1070,
				delay: 3000, // 3秒
				msg: "等离子",
				desc: "启动等离子",
				ttl: 3,
				errorCheck: (data) => this.checkPlasmaStart(data)
			},
			{
				canId: 1080,
				delay: 3000, // 3秒
				msg: "关闭等离子",
				desc: "提前15s关等离子",
				ttl: 3,
				errorCheck: () => null // 无特殊校验
			}
		],

		//第二步
		[{
				canId: 1010,
				delay: 12000, // 12秒
				msg: "加液",
				desc: "用时120S 未到干燥压力值报警，4秒内检测一次",
				ttl: 10,
				errorCheck: () => null // 无特殊校验
			},
			{
				canId: 1020,
				delay: 4000, // 4秒
				msg: "加液验证压力值",
				desc: "压力<加液验证压力值,报警E05",
				ttl: 10,
				errorCheck: () => null // 无特殊校验
			},
			{
				canId: 1030,
				delay: 3000, // 3秒
				msg: "保持动作时间",
				desc: "操作注射",
				ttl: 20,
				errorCheck: () => null // 无特殊校验
			}
		],

		//第三步
		[{
				canId: 1010,
				delay: 12000, // 12秒
				msg: "开新风",
				desc: "作用管腔,内胆密封",
				ttl: 5,
				errorCheck: () => null // 无特殊校验
			},
			{
				canId: 1020,
				delay: 4000, // 4秒
				msg: "再次开新风",
				desc: "通风要求",
				ttl: 10,
				errorCheck: () => null // 无特殊校验
			}
		],

		//第四步
		[{
				canId: 1010,
				delay: 12000, // 12秒
				msg: "抽真空",
				desc: "到达时间后检测，内胆气压>180Pa则降压失败，报警E07",
				ttl: 10,
				errorCheck: () => null // 无特殊校验
			},
			{
				canId: 1020,
				delay: 4000, // 4秒
				msg: "等离子体",
				desc: "启动等离子，如果三次均未成功，报警E23",
				ttl: 10,
				errorCheck: () => null // 无特殊校验
			},
			{
				canId: 1030,
				delay: 3000, // 3秒
				msg: "关闭等离子",
				desc: "提前15s关等离子",
				ttl: 20,
				errorCheck: () => null // 无特殊校验
			}
		],
		//第五步
		[{
				canId: 1010,
				delay: 12000, // 12秒
				msg: "开新风",
				desc: "如果时间内内胆压力没有恢复至10000Pa，则会报警E09",
				ttl: 5,
				errorCheck: () => null // 无特殊校验
			},
			{
				canId: 1020,
				delay: 4000, // 4秒
				msg: "再次开新风",
				desc: "即将完成",
				ttl: 10,
				errorCheck: () => null // 无特殊校验
			}
		],
	];

	constructor(type) {

		this.#serial = new serial();
		// 统一监听串口数据，分发到通用处理方法
		this.#serial.watch = (canId, data) => this.handleStepData(canId, data);
		this.store = runderStore();
		this.store.setRunType(type)
	}

	// 启动流程（替代原 runder 方法）
	start() {
		this.#i = 0;
		this.#exec(this.#i);
		this.store.setRun(true)
	}

	#exec(i) {
		if (i < 0 || i >= this.steps.length) {
			/**
			 * 返回所有数据生成日志保存
			 */
			this.success('success');

			//完成后或中断后初始化数据
			this.store.initData();
			return console.error("全部执行完成");
		}
		this.currentStep = 0;
		const runStep = this.steps[i][this.currentStep];
		//总步骤数
		this.totalSetp = this.steps[i].length;

		this.store.setInfo({
			current: 1,
			msg: runStep.msg,
			desc: runStep.desc,
			setp: this.totalSetp
		})
		//设置当前
		this.store.setCurrent(i)
		this.store.setName(this.menu[i])

		//执行第一个步骤
		this.runStep(0);
	}

	// 通用步骤执行方法
	runStep(index) {
		//当前步骤
		this.currentStep = index;
		const step = this.steps[this.#i][index];
		if (!step) {
			// 所有步骤执行完成
			console.log('-----------当前步骤完成------------')
			//设置进度百分比
			this.store.setProgress(100)
			setTimeout(() => {
				this.store.setProgress(0)
			}, 1000)
			
			console.log('==========下一个步骤开始==========')
			this.#i++
			this.#exec(this.#i)
			return
		}

		console.log(`SETP${index + 1}: ${step.msg}`);
		setTimeout(() => {
			this.#serial.send(step.canId);
		}, step.delay);
	}

	// 通用步骤数据处理方法
	handleStepData(canId, data) {
		// 找到当前步骤对应的配置
			const setpData = this.steps[this.#i];
		const stepIndex = setpData.findIndex(step => step.canId === canId);
	
		// 过滤无效数据（非当前步骤的消息）
		if (stepIndex === -1 || stepIndex !== this.currentStep) return;

		// 执行当前步骤的错误校验
		const error = setpData[stepIndex].errorCheck(data);
		if (error) {
			return this.err(error.msg, error.code);
		}

		// 准备下一步
		const nextIndex = stepIndex + 1;

		this.store.setInfo({
			current: nextIndex + 1,
			msg: setpData[nextIndex]?.msg || '',
			desc: setpData[nextIndex]?.desc || '',
			setp: this.totalSetp
		})

		//设置进度百分比
		this.store.setProgress(Math.ceil(nextIndex / this.totalSetp * 100))

		// 执行下一步
		this.runStep(nextIndex);
		
	}

	// 压力检测通用逻辑
	checkPressure(data, type) {
		const pressure = data.pressure; // 假设数据格式包含 pressure 字段
		if (type === 'dry' && pressure > this.dryPressureThreshold) {
			return {
				code: 'E1',
				msg: '内胆预真空降压失败'
			};
		}
		if (type === 'vacuum' && pressure > this.dryPressureThreshold) {
			return {
				code: 'E1',
				msg: '灭菌舱降压失败'
			};
		}
		return null;
	}

	// 泄漏率检测逻辑
	checkLeakRate(data) {
		// const leakRate = Math.abs(data.p1 - data.p2) / 30; // 计算泄漏率
		// if (leakRate > this.leakThreshold) {
		//   return { code: 'E3', msg: '内胆泄漏率超标' };
		// }
		return null;
	}

	// 等离子压力检测（步骤6）
	checkPlasmaPressure(data) {
		// if (data.pressure > 180) { // 需抽到180Pa以下
		//   return { code: 'plasma_fail', msg: '等离子降压失败' };
		// }
		return null;
	}

	// 等离子启动检测（步骤7）
	checkPlasmaStart(data) {
		// if (!data.success) {
		//   // 未启动成功时重试
		//   if (this.plasmaRetryCount < this.plasmaMaxRetry) {
		//     this.plasmaRetryCount++;
		//     console.log(`等离子启动失败，重试第${this.plasmaRetryCount}次`);
		//     // 重新执行当前步骤
		//     this.runStep(6);
		//     return { code: 'temp', msg: '等离子启动重试中' }; // 临时错误，不终止流程
		//   } else {
		//     // 超过最大重试次数
		//     return { code: 'plasma_fail', msg: '等离子电源异常' };
		//   }
		// }
		return null;
	}


	// 成功回调（可扩展为事件通知）
	success(type, payload) {
		// 实际场景中可改为事件触发（如 this.emit(type, payload)）
		console.log(`[${type}]`, payload);
	}

	// 错误处理（可扩展为错误上报）
	err(msg, code) {
		console.error(`[错误 ${code}]`, msg);

		//完成后或中断后初始化数据
		this.store.initData();
		this.success('error', {
			code,
			msg
		});
		// 可选：需要时中断流程
		// this.currentStep = -1;
	}
}

export default singleton(RunStep);